Регистрация

Поиск скриптов по запросу "high low"

real_time_candlesIntroduction The Real-Time Candles Library provides comprehensive tools for creating, manipulating, and visualizing custom timeframe candles in Pine Script. Unlike standard indicators that only update at bar close, this library enables real-time visualization of price action and indicators within the current bar, offering traders unprecedented insight into market dynamics as they unfold. This library addresses a fundamental limitation in traditional technical analysis: the inability to see how indicators evolve between bar closes. By implementing sophisticated real-time data processing techniques, traders can now observe indicator movements, divergences, and trend changes as they develop, potentially identifying trading opportunities much earlier than with conventional approaches. Key Features The library supports two primary candle generation approaches: Chart-Time Candles: Generate real-time OHLC data for any variable (like RSI, MACD, etc.) while maintaining synchronization with chart bars. Custom Timeframe (CTF) Candles: Create candles with custom time intervals or tick counts completely independent of the chart's native timeframe. Both approaches support traditional candlestick and Heikin-Ashi visualization styles, with options for moving average overlays to smooth the data. Configuration Requirements For optimal performance with this library: Set max_bars_back = 5000 in your script settings When using CTF drawing functions, set max_lines_count = 500, max_boxes_count = 500, and max_labels_count = 500 These settings ensure that you will be able to draw correctly and will avoid any runtime errors. Usage Examples Basic Chart-Time Candle Visualization // Create real-time candles for RSI float rsi = ta.rsi(close, 14) Candle rsi_candle = candle_series(rsi, CandleType.candlestick) // Plot the candles using Pine's built-in function plotcandle(rsi_candle.Open, rsi_candle.High, rsi_candle.Low, rsi_candle.Close, "RSI Candles", rsi_candle.candle_color, rsi_candle.candle_color) Multiple Access Patterns The library provides three ways to access candle data, accommodating different programming styles: // 1. Array-based access for collection operations Candle candles = candle_array(source) // 2. Object-oriented access for single entity manipulation Candle candle = candle_series(source) float value = candle.source(Source.HLC3) // 3. Tuple-based access for functional programming styles = candle_tuple(source) Custom Timeframe Examples // Create 20-second candles with EMA overlay plot_ctf_candles( source = close, candle_type = CandleType.candlestick, sample_type = SampleType.Time, number_of_seconds = 20, timezone = -5, tied_open = true, ema_period = 9, enable_ema = true ) // Create tick-based candles (new candle every 15 ticks) plot_ctf_tick_candles( source = close, candle_type = CandleType.heikin_ashi, number_of_ticks = 15, timezone = -5, tied_open = true ) Advanced Usage with Custom Visualization // Get custom timeframe candles without automatic plotting CandleCTF my_candles = ctf_candles_array( source = close, candle_type = CandleType.candlestick, sample_type = SampleType.Time, number_of_seconds = 30 ) // Apply custom logic to the candles float ema_values = my_candles.ctf_ema(14) // Draw candles and EMA using time-based coordinates my_candles.draw_ctf_candles_time() ema_values.draw_ctf_line_time(line_color = #FF6D00) Library Components Data Types Candle: Structure representing chart-time candles with OHLC, polarity, and visualization properties CandleCTF: Extended candle structure with additional time metadata for custom timeframes TickData: Structure for individual price updates with time deltas Enumerations CandleType: Specifies visualization style (candlestick or Heikin-Ashi) Source: Defines price components for calculations (Open, High, Low, Close, HL2, etc.) SampleType: Sets sampling method (Time-based or Tick-based) Core Functions get_tick(): Captures current price as a tick data point candle_array(): Creates an array of candles from price updates candle_series(): Provides a single candle based on latest data candle_tuple(): Returns OHLC values as a tuple ctf_candles_array(): Creates custom timeframe candles without rendering Visualization Functions source(): Extracts specific price components from candles candle_ctf_to_float(): Converts candle data to float arrays ctf_ema(): Calculates exponential moving averages for candle arrays draw_ctf_candles_time(): Renders candles using time coordinates draw_ctf_candles_index(): Renders candles using bar index coordinates draw_ctf_line_time(): Renders lines using time coordinates draw_ctf_line_index(): Renders lines using bar index coordinates Technical Implementation Notes This library leverages Pine Script's varip variables for state management, creating a sophisticated real-time data processing system. The implementation includes: Efficient tick capturing: Samples price at every execution, maintaining temporal tracking with time deltas Smart state management: Uses a hybrid approach with mutable updates at index 0 and historical preservation at index 1+ Temporal synchronization: Manages two time domains (chart time and custom timeframe) The tooltip implementation provides crucial temporal context for custom timeframe visualizations, allowing users to understand exactly when each candle formed regardless of chart timeframe. Limitations Custom timeframe candles cannot be backtested due to Pine Script's limitations with historical tick data Real-time visualization is only available during live chart updates Maximum history is constrained by Pine Script's array size limits Applications Indicator visualization: See how RSI, MACD, or other indicators evolve in real-time Volume analysis: Create custom volume profiles independent of chart timeframe Scalping strategies: Identify short-term patterns with precisely defined time windows Volatility measurement: Track price movement characteristics within bars Custom signal generation: Create entry/exit signals based on custom timeframe patterns Conclusion The Real-Time Candles Library bridges the gap between traditional technical analysis (based on discrete OHLC bars) and the continuous nature of market movement. By making indicators more responsive to real-time price action, it gives traders a significant edge in timing and decision-making, particularly in fast-moving markets where waiting for bar close could mean missing important opportunities. Whether you're building custom indicators, researching price patterns, or developing trading strategies, this library provides the foundation for sophisticated real-time analysis in Pine Script. Implementation Details & Advanced Guide Core Implementation Concepts The Real-Time Candles Library implements a sophisticated event-driven architecture within Pine Script's constraints. At its heart, the library creates what's essentially a reactive programming framework handling continuous data streams. Tick Processing System The foundation of the library is the get_tick() function, which captures price updates as they occur: export get_tick(series float source = close, series float na_replace = na)=> varip float price = na varip int series_index = -1 varip int old_time = 0 varip int new_time = na varip float time_delta = 0 // ... This function: Samples the current price Calculates time elapsed since last update Maintains a sequential index to track updates The resulting TickData structure serves as the fundamental building block for all candle generation. State Management Architecture The library employs a sophisticated state management system using varip variables, which persist across executions within the same bar. This creates a hybrid programming paradigm that's different from standard Pine Script's bar-by-bar model. For chart-time candles, the core state transition logic is: // Real-time update of current candle candle_data := Candle.new(Open, High, Low, Close, polarity, series_index, candle_color) candles.set(0, candle_data) // When a new bar starts, preserve the previous candle if clear_state candles.insert(1, candle_data) price.clear() // Reset state for new candle Open := Close price.push(Open) series_index += 1 This pattern of updating index 0 in real-time while inserting completed candles at index 1 creates an elegant solution for maintaining both current state and historical data. Custom Timeframe Implementation The custom timeframe system manages its own time boundaries independent of chart bars: bool clear_state = switch settings.sample_type SampleType.Ticks => cumulative_series_idx >= settings.number_of_ticks SampleType.Time => cumulative_time_delta >= settings.number_of_seconds This dual-clock system synchronizes two time domains: Pine's execution clock (bar-by-bar processing) The custom timeframe clock (tick or time-based) The library carefully handles temporal discontinuities, ensuring candle formation remains accurate despite irregular tick arrival or market gaps. Advanced Usage Techniques 1. Creating Custom Indicators with Real-Time Candles To develop indicators that process real-time data within the current bar: // Get real-time candles for your data Candle rsi_candles = candle_array(ta.rsi(close, 14)) // Calculate indicator values based on candle properties float signal = ta.ema(rsi_candles.first().source(Source.Close), 9) // Detect patterns that occur within the bar bool divergence = close > close and rsi_candles.first().Close < rsi_candles.get(1).Close 2. Working with Custom Timeframes and Plotting For maximum flexibility when visualizing custom timeframe data: // Create custom timeframe candles CandleCTF volume_candles = ctf_candles_array( source = volume, candle_type = CandleType.candlestick, sample_type = SampleType.Time, number_of_seconds = 60 ) // Convert specific candle properties to float arrays float volume_closes = volume_candles.candle_ctf_to_float(Source.Close) // Calculate derived values float volume_ema = volume_candles.ctf_ema(14) // Create custom visualization volume_candles.draw_ctf_candles_time() volume_ema.draw_ctf_line_time(line_color = color.orange) 3. Creating Hybrid Timeframe Analysis One powerful application is comparing indicators across multiple timeframes: // Standard chart timeframe RSI float chart_rsi = ta.rsi(close, 14) // Custom 5-second timeframe RSI CandleCTF ctf_candles = ctf_candles_array( source = close, candle_type = CandleType.candlestick, sample_type = SampleType.Time, number_of_seconds = 5 ) float fast_rsi_array = ctf_candles.candle_ctf_to_float(Source.Close) float fast_rsi = fast_rsi_array.first() // Generate signals based on divergence between timeframes bool entry_signal = chart_rsi < 30 and fast_rsi > fast_rsi_array.get(1) Final Notes This library represents an advanced implementation of real-time data processing within Pine Script's constraints. By creating a reactive programming framework for handling continuous data streams, it enables sophisticated analysis typically only available in dedicated trading platforms. The design principles employed—including state management, temporal processing, and object-oriented architecture—can serve as patterns for other advanced Pine Script development beyond this specific application. ------------------------ Library "real_time_candles" A comprehensive library for creating real-time candles with customizable timeframes and sampling methods. Supports both chart-time and custom-time candles with options for candlestick and Heikin-Ashi visualization. Allows for tick-based or time-based sampling with moving average overlay capabilities. get_tick(source, na_replace)   Captures the current price as a tick data point   Parameters:      source (float) : Optional - Price source to sample (defaults to close)      na_replace (float) : Optional - Value to use when source is na   Returns: TickData structure containing price, time since last update, and sequential index candle_array(source, candle_type, sync_start, bullish_color, bearish_color)   Creates an array of candles based on price updates   Parameters:      source (float) : Optional - Price source to sample (defaults to close)      candle_type (simple CandleType) : Optional - Type of candle chart to create (candlestick or Heikin-Ashi)      sync_start (simple bool) : Optional - Whether to synchronize with the start of a new bar      bullish_color (color) : Optional - Color for bullish candles      bearish_color (color) : Optional - Color for bearish candles   Returns: Array of Candle objects ordered with most recent at index 0 candle_series(source, candle_type, wait_for_sync, bullish_color, bearish_color)   Provides a single candle based on the latest price data   Parameters:      source (float) : Optional - Price source to sample (defaults to close)      candle_type (simple CandleType) : Optional - Type of candle chart to create (candlestick or Heikin-Ashi)      wait_for_sync (simple bool) : Optional - Whether to wait for a new bar before starting      bullish_color (color) : Optional - Color for bullish candles      bearish_color (color) : Optional - Color for bearish candles   Returns: A single Candle object representing the current state candle_tuple(source, candle_type, wait_for_sync, bullish_color, bearish_color)   Provides candle data as a tuple of OHLC values   Parameters:      source (float) : Optional - Price source to sample (defaults to close)      candle_type (simple CandleType) : Optional - Type of candle chart to create (candlestick or Heikin-Ashi)      wait_for_sync (simple bool) : Optional - Whether to wait for a new bar before starting      bullish_color (color) : Optional - Color for bullish candles      bearish_color (color) : Optional - Color for bearish candles   Returns: Tuple representing current candle values method source(self, source, na_replace)   Extracts a specific price component from a Candle   Namespace types: Candle   Parameters:      self (Candle)      source (series Source) : Type of price data to extract (Open, High, Low, Close, or composite values)      na_replace (float) : Optional - Value to use when source value is na   Returns: The requested price value from the candle method source(self, source)   Extracts a specific price component from a CandleCTF   Namespace types: CandleCTF   Parameters:      self (CandleCTF)      source (simple Source) : Type of price data to extract (Open, High, Low, Close, or composite values)   Returns: The requested price value from the candle as a varip method candle_ctf_to_float(self, source)   Converts a specific price component from each CandleCTF to a float array   Namespace types: array   Parameters:      self (array)      source (simple Source) : Optional - Type of price data to extract (defaults to Close)   Returns: Array of float values extracted from the candles, ordered with most recent at index 0 method ctf_ema(self, ema_period)   Calculates an Exponential Moving Average for a CandleCTF array   Namespace types: array   Parameters:      self (array)      ema_period (simple float) : Period for the EMA calculation   Returns: Array of float values representing the EMA of the candle data, ordered with most recent at index 0 method draw_ctf_candles_time(self, sample_type, number_of_ticks, number_of_seconds, timezone)   Renders custom timeframe candles using bar time coordinates   Namespace types: array   Parameters:      self (array)      sample_type (simple SampleType) : Optional - Method for sampling data (Time or Ticks), used for tooltips      number_of_ticks (simple int) : Optional - Number of ticks per candle (used when sample_type is Ticks), used for tooltips      number_of_seconds (simple float) : Optional - Time duration per candle in seconds (used when sample_type is Time), used for tooltips      timezone (simple int) : Optional - Timezone offset from UTC (-12 to +12), used for tooltips   Returns: void - Renders candles on the chart using time-based x-coordinates method draw_ctf_candles_index(self, sample_type, number_of_ticks, number_of_seconds, timezone)   Renders custom timeframe candles using bar index coordinates   Namespace types: array   Parameters:      self (array)      sample_type (simple SampleType) : Optional - Method for sampling data (Time or Ticks), used for tooltips      number_of_ticks (simple int) : Optional - Number of ticks per candle (used when sample_type is Ticks), used for tooltips      number_of_seconds (simple float) : Optional - Time duration per candle in seconds (used when sample_type is Time), used for tooltips      timezone (simple int) : Optional - Timezone offset from UTC (-12 to +12), used for tooltips   Returns: void - Renders candles on the chart using index-based x-coordinates method draw_ctf_line_time(self, source, line_size, line_color)   Renders a line representing a price component from the candles using time coordinates   Namespace types: array   Parameters:      self (array)      source (simple Source) : Optional - Type of price data to extract (defaults to Close)      line_size (simple int) : Optional - Width of the line      line_color (simple color) : Optional - Color of the line   Returns: void - Renders a connected line on the chart using time-based x-coordinates method draw_ctf_line_time(self, line_size, line_color)   Renders a line from a varip float array using time coordinates   Namespace types: array   Parameters:      self (array)      line_size (simple int) : Optional - Width of the line, defaults to 2      line_color (simple color) : Optional - Color of the line   Returns: void - Renders a connected line on the chart using time-based x-coordinates method draw_ctf_line_index(self, source, line_size, line_color)   Renders a line representing a price component from the candles using index coordinates   Namespace types: array   Parameters:      self (array)      source (simple Source) : Optional - Type of price data to extract (defaults to Close)      line_size (simple int) : Optional - Width of the line      line_color (simple color) : Optional - Color of the line   Returns: void - Renders a connected line on the chart using index-based x-coordinates method draw_ctf_line_index(self, line_size, line_color)   Renders a line from a varip float array using index coordinates   Namespace types: array   Parameters:      self (array)      line_size (simple int) : Optional - Width of the line, defaults to 2      line_color (simple color) : Optional - Color of the line   Returns: void - Renders a connected line on the chart using index-based x-coordinates plot_ctf_tick_candles(source, candle_type, number_of_ticks, timezone, tied_open, ema_period, bullish_color, bearish_color, line_width, ema_color, use_time_indexing)   Plots tick-based candles with moving average   Parameters:      source (float) : Input price source to sample      candle_type (simple CandleType) : Type of candle chart to display      number_of_ticks (simple int) : Number of ticks per candle      timezone (simple int) : Timezone offset from UTC (-12 to +12)      tied_open (simple bool) : Whether to tie open price to close of previous candle      ema_period (simple float) : Period for the exponential moving average      bullish_color (color) : Optional - Color for bullish candles      bearish_color (color) : Optional - Color for bearish candles      line_width (simple int) : Optional - Width of the moving average line, defaults to 2      ema_color (color) : Optional - Color of the moving average line      use_time_indexing (simple bool) : Optional - When true the function will plot with xloc.time, when false it will plot using xloc.bar_index   Returns: void - Creates visual candle chart with EMA overlay plot_ctf_tick_candles(source, candle_type, number_of_ticks, timezone, tied_open, bullish_color, bearish_color, use_time_indexing)   Plots tick-based candles without moving average   Parameters:      source (float) : Input price source to sample      candle_type (simple CandleType) : Type of candle chart to display      number_of_ticks (simple int) : Number of ticks per candle      timezone (simple int) : Timezone offset from UTC (-12 to +12)      tied_open (simple bool) : Whether to tie open price to close of previous candle      bullish_color (color) : Optional - Color for bullish candles      bearish_color (color) : Optional - Color for bearish candles      use_time_indexing (simple bool) : Optional - When true the function will plot with xloc.time, when false it will plot using xloc.bar_index   Returns: void - Creates visual candle chart without moving average plot_ctf_time_candles(source, candle_type, number_of_seconds, timezone, tied_open, ema_period, bullish_color, bearish_color, line_width, ema_color, use_time_indexing)   Plots time-based candles with moving average   Parameters:      source (float) : Input price source to sample      candle_type (simple CandleType) : Type of candle chart to display      number_of_seconds (simple float) : Time duration per candle in seconds      timezone (simple int) : Timezone offset from UTC (-12 to +12)      tied_open (simple bool) : Whether to tie open price to close of previous candle      ema_period (simple float) : Period for the exponential moving average      bullish_color (color) : Optional - Color for bullish candles      bearish_color (color) : Optional - Color for bearish candles      line_width (simple int) : Optional - Width of the moving average line, defaults to 2      ema_color (color) : Optional - Color of the moving average line      use_time_indexing (simple bool) : Optional - When true the function will plot with xloc.time, when false it will plot using xloc.bar_index   Returns: void - Creates visual candle chart with EMA overlay plot_ctf_time_candles(source, candle_type, number_of_seconds, timezone, tied_open, bullish_color, bearish_color, use_time_indexing)   Plots time-based candles without moving average   Parameters:      source (float) : Input price source to sample      candle_type (simple CandleType) : Type of candle chart to display      number_of_seconds (simple float) : Time duration per candle in seconds      timezone (simple int) : Timezone offset from UTC (-12 to +12)      tied_open (simple bool) : Whether to tie open price to close of previous candle      bullish_color (color) : Optional - Color for bullish candles      bearish_color (color) : Optional - Color for bearish candles      use_time_indexing (simple bool) : Optional - When true the function will plot with xloc.time, when false it will plot using xloc.bar_index   Returns: void - Creates visual candle chart without moving average plot_ctf_candles(source, candle_type, sample_type, number_of_ticks, number_of_seconds, timezone, tied_open, ema_period, bullish_color, bearish_color, enable_ema, line_width, ema_color, use_time_indexing)   Unified function for plotting candles with comprehensive options   Parameters:      source (float) : Input price source to sample      candle_type (simple CandleType) : Optional - Type of candle chart to display      sample_type (simple SampleType) : Optional - Method for sampling data (Time or Ticks)      number_of_ticks (simple int) : Optional - Number of ticks per candle (used when sample_type is Ticks)      number_of_seconds (simple float) : Optional - Time duration per candle in seconds (used when sample_type is Time)      timezone (simple int) : Optional - Timezone offset from UTC (-12 to +12)      tied_open (simple bool) : Optional - Whether to tie open price to close of previous candle      ema_period (simple float) : Optional - Period for the exponential moving average      bullish_color (color) : Optional - Color for bullish candles      bearish_color (color) : Optional - Color for bearish candles      enable_ema (bool) : Optional - Whether to display the EMA overlay      line_width (simple int) : Optional - Width of the moving average line, defaults to 2      ema_color (color) : Optional - Color of the moving average line      use_time_indexing (simple bool) : Optional - When true the function will plot with xloc.time, when false it will plot using xloc.bar_index   Returns: void - Creates visual candle chart with optional EMA overlay ctf_candles_array(source, candle_type, sample_type, number_of_ticks, number_of_seconds, tied_open, bullish_color, bearish_color)   Creates an array of custom timeframe candles without rendering them   Parameters:      source (float) : Input price source to sample      candle_type (simple CandleType) : Type of candle chart to create (candlestick or Heikin-Ashi)      sample_type (simple SampleType) : Method for sampling data (Time or Ticks)      number_of_ticks (simple int) : Optional - Number of ticks per candle (used when sample_type is Ticks)      number_of_seconds (simple float) : Optional - Time duration per candle in seconds (used when sample_type is Time)      tied_open (simple bool) : Optional - Whether to tie open price to close of previous candle      bullish_color (color) : Optional - Color for bullish candles      bearish_color (color) : Optional - Color for bearish candles   Returns: Array of CandleCTF objects ordered with most recent at index 0 Candle   Structure representing a complete candle with price data and display properties   Fields:      Open (series float) : Opening price of the candle      High (series float) : Highest price of the candle      Low (series float) : Lowest price of the candle      Close (series float) : Closing price of the candle      polarity (series bool) : Boolean indicating if candle is bullish (true) or bearish (false)      series_index (series int) : Sequential index identifying the candle in the series      candle_color (series color) : Color to use when rendering the candle      ready (series bool) : Boolean indicating if candle data is valid and ready for use TickData   Structure for storing individual price updates   Fields:      price (series float) : The price value at this tick      time_delta (series float) : Time elapsed since the previous tick in milliseconds      series_index (series int) : Sequential index identifying this tick CandleCTF   Structure representing a custom timeframe candle with additional time metadata   Fields:      Open (series float) : Opening price of the candle      High (series float) : Highest price of the candle      Low (series float) : Lowest price of the candle      Close (series float) : Closing price of the candle      polarity (series bool) : Boolean indicating if candle is bullish (true) or bearish (false)      series_index (series int) : Sequential index identifying the candle in the series      open_time (series int) : Timestamp marking when the candle was opened (in Unix time)      time_delta (series float) : Duration of the candle in milliseconds      candle_color (series color) : Color to use when rendering the candle
Библиотека Pine Script®
от The_Peaceful_Lizard
29
MTF Ichimoku Conversion Line SMA with H/L mirrored levelsWelcome to MTF Ichimoku Conversion Line with SMA Highs/Lows Extended Lines! 1. Overview It is designed to provide a multi-timeframe view of market trends and potential support/resistance levels by obtaining a Simple Moving Average (SMA) of the Conversion Line of Ichimoku Equibilium (Ichimoku Kinko-Hyo), which acts as a substantial trend line on the candlestick chart. The SMA of the conversion line smooths out price fluctuations and indicates the overall trend direction—if the candles are above it, the trend can be read as an uptrend, while below it, the trend can be read as a downtrend. 2. Calculation The indicator first calculates the Conversion Line (see the description of Ichimoku theory anywhere, e.g., Wikipedia), as the average of the highest high and lowest low over a user-defined period (Conversion Line Length, default is 9, also recommended is 9). It then retrieves this Conversion Line from a higher timeframe (MTF Timeframe) to add a broader perspective. Using a specified period (SMA Length)., an SMA is computed on this multi-timeframe conversion line. This SMA serves as a trend line that visually represents the prevailing price trend, making it easier to assess market direction. 3. Pivot Highs/low detection and drawing their extensions In addition, the indicator identifies pivot highs and lows from the SMA data using a defined pivot length. When these pivots occur, horizontal lines are drawn and extended across the chart. These extended lines (drawn in a yellowish color by default) include a full extension, a half extension, and a middle extension line representing the midpoint between the high and low pivot. 4. Mirror lines The indicator also offers optional mirror line features. When the Mirror Upside option is enabled, five additional lines are drawn above the highest extended yellow line at equal intervals. Similarly, when the Mirror Downside option is enabled, five lines are drawn below the lowest extended yellow line. These light gray mirror lines serve as extra reference levels, which can help identify potential support or resistance zones. 5. Parameters User parameters include: - Conversion Line Length: The period used to calculate the conversion line. - MTF Timeframe: The higher timeframe from which the conversion line is obtained. - SMA Length: The period over which the SMA is calculated on the conversion line. - SMA Mode: A toggle to display either the SMA or the raw conversion line (SMA recommended). - SMA Line Width: The thickness of the SMA line. - Pivot Length for SMA Highs/Lows: The period used to detect pivot highs and lows in the SMA. - Horizontal Extension: Number of bars by which the pivot and extended lines are drawn across the chart - Colors for High and Low Pivot Lines and Extended Lines: Customizable colors are used to draw the lines. Mirror Upside and Mirror Downside: These options enable drawing additional mirror lines above and below the extended lines. - Hide Old Lines: An option to hide previous pivot lines once new ones are drawn for a cleaner chart. Turned on by default. 6. Conclusion Overall, the Conversion Line SMA in this indicator smooths out the conversion line data and effectively functions as a trend line for the candlestick chart, helping traders visually interpret the underlying market trend. The extended and mirror lines provide further context for potential price reversal or continuation areas, making this a powerful tool for multi-timeframe technical analysis.
Индикатор Pine Script®
от Darth_Neccoder
2
Opening Range, Initial Balance, Opening Price, Pre-market Levels### Description of the Indicator: **Opening Range, Initial Balance, Opening Price, Pre-market Levels** This custom TradingView indicator provides a comprehensive view of key price levels for intraday trading, specifically designed to track important levels from the Opening Range (OR), Initial Balance (IB), Opening Price (OP), and Pre-market session (PM). These levels are essential for traders to gauge potential market movements and identify critical areas of support and resistance. #### **Features:** 1. **Opening Range (OR):** - This is the high and low of the first 30 minutes of the regular market session (09:30 - 10:00 EST). - The OR high and low act as significant levels that may influence price movement for the rest of the day. - The mid-level of the Opening Range (OR Mid) is also plotted to give a more detailed view of potential price action. 2. **Initial Balance (IB):** - The Initial Balance is the range created during the first hour of market activity (09:30 - 10:30 EST). - This range often sets the tone for the market's direction. The IB high and low, along with the IB midline, are plotted for quick reference. 3. **Opening Price (OP):** - The opening price of the market is marked as a circle and labeled "OP." - This level provides context for market sentiment when compared to the high and low levels. 4. **Pre-market Levels (PM):** - The pre-market session (04:00 - 09:30 EST) has its own important levels that are calculated for the high, low, and mid range (PM High, PM Low, and PM Mid). - These levels are plotted and are useful for traders to understand where the market stood before the regular session opened. #### **Customization Options:** - **Exchange Timezone:** You can choose whether to display the times in the exchange's local timezone or in your own preferred timezone. - **Mid Levels Display:** You can toggle whether the mid levels for each range (OR, IB, PM) should be shown on the chart. - **Level Color Change:** The colors of the plotted levels (high, low, mid) change based on whether the price is above or below the respective level, making it easy to visualize potential support and resistance. - **Label Positions:** The position of the labels (OR, IB, OP, PM) on the chart can be customized to avoid overlap with other data points. #### **Key Use Cases:** - **Intraday Trend Analysis:** Use the OR and IB to identify key levels for the day, providing insights into the possible trend or range for the day. - **Pre-market Insights:** The PM levels are crucial for understanding where the market stood during the pre-market hours and can be used as reference points during the regular session. - **Potential Support and Resistance:** The high and low levels of the OR, IB, and PM sessions can act as potential support or resistance, which are useful for setting stop-loss and take-profit levels. #### **How to Use:** - Pay attention to the levels provided for OR, IB, and PM as potential entry and exit points. - Watch for breakouts or reversals around these levels, especially when combined with other technical indicators or price action patterns. - The mid levels offer an additional reference to assess price direction or identify possible areas of consolidation. This indicator is perfect for day traders who rely on key intraday levels and pre-market activity to make informed trading decisions. It helps to streamline the process of identifying potential breakouts, reversals, and ranges in the market.
Индикатор Pine Script®
от celynuik
[GrandAlgo] MTF Historical Highs and LowsMany traders rely on weekly highs and lows to identify key market levels, but what if you could see how price reacted to these levels in past weeks, months, or even years? With MTF Historical Highs and Lows, you can visualize all past highs, lows, and midpoints from any timeframe, allowing you to refine your strategy and make more informed trading decisions. This indicator retrieves and plots historical highs, lows, and midpoints based on a user-selected timeframe (default: Weekly). It dynamically updates, ensuring that all significant price levels remain visible on your chart. Additionally, smart filtering helps you focus only on relevant levels, and alerts notify you when price interacts with key zones. Key Features: ✅ Automatically Fetches & Plots Historical Highs, Lows, and Midpoints ✅ Customizable Timeframes (default: Weekly, but adjustable) ✅ Visibility Filtering – Hides lines that are too far from the current price ✅ Alerts for Key Levels – Get notified when price touches an important historical level ✅ Customizable Colors & Display Preferences for clarity How It Works: 1️⃣ Select a Date Range – Focus on historical levels that are most relevant to the current market conditions 2️⃣ Choose a Timeframe – Use Weekly, Monthly, or any timeframe that suits your strategy. 3️⃣ Enable Highs, Lows, and Midpoints – Customize what you want to see. 4️⃣ Adjust Filtering – Hide lines that are too far from the current price to reduce clutter. 5️⃣ Get Alerts – Be notified when price reaches a historical level for potential trade setups. Ideal for Traders Who: Trade Support & Resistance Levels – Understand how price reacts at historical highs and lows. Analyze Market Structure – Identify key areas where price may reverse or break out. Want Smart Alerts – Stay informed without staring at charts all day.
Индикатор Pine Script®
от GrandAlgo
2022 Model ICT Entry Strategy [TradingFinder] One Setup For Life🔵 Introduction The ICT 2022 model, introduced by Michael Huddleston, is an advanced trading strategy rooted in liquidity and price imbalance, where time and price serve as the core elements. This ICT 2022 trading strategy is an algorithmic approach designed to analyze liquidity and imbalances in the market. It incorporates concepts such as Fair Value Gap (FVG), Liquidity Sweep, and Market Structure Shift (MSS) to help traders identify liquidity movements and structural changes in the market, enabling them to determine optimal entry and exit points for their trades. This Full ICT Day Trading Model empowers traders to pinpoint the Previous Day High/Low as well as the highs and lows of critical sessions like the London and New York sessions. These levels act as Liquidity Zones, which are frequently swept prior to a market structure shift (MSS) or a retracement to areas such as Optimal Trade Entry (OTE). Bullish : Bearish : 🔵 How to Use The ICT 2022 model is a sophisticated trading strategy that focuses on identifying key liquidity levels and price movements. It operates based on two main principles. In the first phase, the price approaches liquidity zones and sweeps critical levels such as the previous day’s high or low and key session levels. This movement is known as a Liquidity Sweep. In the second phase, following the sweep, the price retraces to areas like the FVG (Fair Value Gap), creating ideal entry points for trades. Below is a detailed explanation of how to apply this strategy in bullish and bearish setups. 🟣 Bullish ICT 2022 Model Setup To use the ICT 2022 model in a bullish setup, start by identifying the Previous Day High/Low or key session levels, such as those of the London or New York sessions. In a bullish setup, the price usually moves downward first, sweeping the Liquidity Low. This move, known as a Liquidity Sweep, reflects the collection of buy orders by major market participants. After the liquidity sweep, the price should shift market structure and start moving upward; this shift, referred to as Market Structure Shift (MSS), signals the beginning of an upward trend. Following MSS, areas like FVG, located within the Discount Zone, are identified. At this stage, the trader waits for the price to retrace to these zones. Once the price returns, a long trade is executed. Finally, the stop-loss should be set below the liquidity low to manage risk, while the take-profit target is usually placed above the previous day’s high or other identified liquidity levels. This structure enables traders to take advantage of the upward price movement after the liquidity sweep. 🟣 Bearish ICT 2022 Model Setup To identify a bearish setup in the ICT 2022 model, begin by marking the Previous Day High/Low or key session levels, such as the London or New York sessions. In this scenario, the price typically moves upward first, sweeping the Liquidity High. This move, known as a Liquidity Sweep, signifies the collection of sell orders by key market players. After the liquidity sweep, the price should shift market structure downward. This movement, called the Market Structure Shift (MSS), indicates the start of a downtrend. Following MSS, areas such as FVG, found within the Premium Zone, are identified. At this stage, the trader waits for the price to retrace to these areas. Once the price revisits these zones, a short trade is executed. In this setup, the stop-loss should be placed above the liquidity high to control risk, while the take-profit target is typically set below the previous day’s low or another defined liquidity level. This approach allows traders to capitalize on the downward price movement following the liquidity sweep. 🔵 Settings Swing period : You can set the swing detection period. Max Swing Back Method : It is in two modes "All" and "Custom". If it is in "All" mode, it will check all swings, and if it is in "Custom" mode, it will check the swings to the extent you determine. Max Swing Back : You can set the number of swings that will go back for checking. FVG Length : Default is 120 Bar. MSS Length : Default is 80 Bar. FVG Filter : This refines the number of identified FVG areas based on a specified algorithm to focus on higher quality signals and reduce noise. Types of FVG filters : Very Aggressive Filter: Adds a condition where, for an upward FVG, the last candle's highest price must exceed the middle candle's highest price, and for a downward FVG, the last candle's lowest price must be lower than the middle candle's lowest price. This minimally filters out FVGs. Aggressive Filter: Builds on the Very Aggressive mode by ensuring the middle candle is not too small, filtering out more FVGs. Defensive Filter: Adds criteria regarding the size and structure of the middle candle, requiring it to have a substantial body and specific polarity conditions, filtering out a significant number of FVGs. Very Defensive Filter: Further refines filtering by ensuring the first and third candles are not small-bodied doji candles, retaining only the highest quality signals. 🔵 Conclusion The ICT 2022 model is a comprehensive and advanced trading strategy designed around key concepts such as liquidity, price imbalance, and market structure shifts (MSS). By focusing on the sweep of critical levels such as the previous day’s high/low and important trading sessions like London and New York, this strategy enables traders to predict market movements with greater precision. The use of tools like FVG in this model helps traders fine-tune their entry and exit points and take advantage of bullish and bearish trends after liquidity sweeps. Moreover, combining this strategy with precise timing during key trading sessions allows traders to minimize risk and maximize returns. In conclusion, the ICT 2022 model emphasizes the importance of time and liquidity, making it a powerful tool for both professional and novice traders. By applying the principles of this model, you can make more informed trading decisions and seize opportunities in financial markets more effectively.
Индикатор Pine Script®
от TFlab
15
Uptrick: Fisher Eclipse1. Name and Purpose Uptrick: Fisher Eclipse is a Pine version 6 extension of the basic Fisher Transform indicator that focuses on highlighting potential turning points in price data. Its purpose is to allow traders to spot shifts in momentum, detect divergence, and adapt signals to different market environments. By combining a core Fisher Transform with additional signal processing, divergence detection, and customizable aggressiveness settings, this script aims to help users see when a price move might be losing momentum or gaining strength. 2. Overview This script uses a Fisher Transform calculation on the average of each bar’s high and low (hl2). The Fisher Transform is designed to amplify price extremes by mapping data into a different scale, making potential reversals more visible than they might be with standard oscillators. Uptrick: Fisher Eclipse takes this concept further by integrating a signal line, divergence detection, bar coloring for momentum intensity, and optional thresholds to reduce unwanted noise. 3. Why Use the Fisher Transform The Fisher Transform is known for converting relatively smoothed price data into a more pronounced scale. This transformation highlights where markets may be overextended. In many cases, standard oscillators move gently, and traders can miss subtle hints that a reversal might be approaching. The Fisher Transform’s mathematical approach tightens the range of values and sharpens the highs and lows. This behavior can allow traders to see clearer peaks and troughs in momentum. Because it is often quite responsive, it can help anticipate areas where price might change direction, especially when compared to simpler moving averages or traditional oscillators. The result is a more evident signal of possible overbought or oversold conditions. 4. How This Extension Improves on the Basic Fisher Transform Uptrick: Fisher Eclipse adds multiple features to the classic Fisher framework in order to address different trading styles and market behaviors: a) Divergence Detection The script can detect bullish or bearish divergences between price and the oscillator over a chosen lookback period, helping traders anticipate shifts in market direction. b) Bar Coloring When momentum exceeds a certain threshold (default 3), bars can be colored to highlight surges of buying or selling pressure. This quick visual reference can assist in spotting periods of heightened activity. After a bar color like this, usually, there is a quick correction as seen in the image below. c) Signal Aggressiveness Levels Users can choose between conservative, moderate, or aggressive signal thresholds. This allows them to tune how quickly the indicator flags potential entries or exits. Aggressive settings might suit scalpers who need rapid signals, while conservative settings may benefit swing traders preferring fewer, more robust indications. d) Minimum Movement Filter A configurable filter can be set to ensure that the Fisher line and its signal have a sufficient gap before triggering a buy or sell signal. This step is useful for traders seeking to minimize signals during choppy or sideways markets. This can be used to eliminate noise as well. By combining all these elements into one package, the indicator attempts to offer a comprehensive toolkit for those who appreciate the Fisher Transform’s clarity but also desire more versatility. 5. Core Components a) Fisher Transform The script calculates a Fisher value using normalized price over a configurable length, highlighting potential peaks and troughs. b) Signal Line The Fisher line is smoothed using a short Simple Moving Average. Crossovers and crossunders are one of the key ways this indicator attempts to confirm momentum shifts. c) Divergence Logic The script looks back over a set number of bars to compare current highs and lows of both price and the Fisher oscillator. When price and the oscillator move in opposing directions, a divergence may occur, suggesting a possible upcoming reversal or weakening trend. d) Thresholds for Overbought and Oversold Horizontal lines are drawn at user-chosen overbought and oversold levels. These lines help traders see when momentum readings reach particular extremes, which can be especially relevant when combined with crossovers in that region. e) Intensity Filter and Bar Coloring If the magnitude of the change in the Fisher Transform meets or exceeds a specified threshold, bars are recolored. This provides a visual cue for significant momentum changes. 6. User Inputs a) length Defines how many bars the script looks back to compute the highest high and lowest low for the Fisher Transform. A smaller length reacts more quickly but can be noisier, while a larger length smooths out the indicator at the cost of responsiveness. b) signal aggressiveness Adjusts the buy and sell thresholds for conservative, moderate, and aggressive trading styles. This can be key in matching the indicator to personal risk preferences or varying market conditions. Conservative will give you less signals and aggressive will give you more signals. c) minimum movement filter Specifies how far apart the Fisher line and its signal line must be before generating a valid crossover signal. d) divergence lookback Controls how many bars are examined when determining if price and the oscillator are diverging. A larger setting might generate fewer signals, while a smaller one can provide more frequent alerts. e) intensity threshold Determines how large a change in the Fisher value must be for the indicator to recolor bars. Strong momentum surges become more noticeable. f) overbought level and oversold level Lets users define where they consider market conditions to be stretched on the upside or downside. 7. Calculation Process a) Price Input The script uses the midpoint of each bar’s high and low, sometimes referred to as hl2. hl2 = (high + low) / 2 b) Range Normalization Determine the maximum (maxHigh) and minimum (minLow) values over a user-defined lookback period (length). Scale the hl2 value so it roughly fits between -1 and +1: value = 2 * ((hl2 - minLow) / (maxHigh - minLow) - 0.5) This step highlights the bar’s current position relative to its recent highs and lows. c) Fisher Calculation Convert the normalized value into the Fisher Transform: fisher = 0.5 * ln( (1 + value) / (1 - value) ) + 0.5 * fisher_previous fisher_previous is simply the Fisher value from the previous bar. Averaging half of the new transform with half of the old value smooths the result slightly and can prevent erratic jumps. ln is the natural logarithm function, which compresses or expands values so that market turns often become more obvious. d) Signal Smoothing Once the Fisher value is computed, a short Simple Moving Average (SMA) is applied to produce a signal line. In code form, this often looks like: signal = sma(fisher, 3) Crossovers of the fisher line versus the signal line can be used to hint at changes in momentum: • A crossover occurs when fisher moves from below to above the signal. • A crossunder occurs when fisher moves from above to below the signal. e) Threshold Checking Users typically define oversold and overbought levels (often -1 and +1). Depending on aggressiveness settings (conservative, moderate, aggressive), these thresholds are slightly shifted to filter out or include more signals. For example, an oversold threshold of -1 might be used in a moderate setting, whereas -1.5 could be used in a conservative setting to require a deeper dip before triggering. f) Divergence Checks The script looks back a specified number of bars (divergenceLookback). For both price and the fisher line, it identifies: • priceHigh = the highest hl2 within the lookback • priceLow = the lowest hl2 within the lookback • fisherHigh = the highest fisher value within the lookback • fisherLow = the lowest fisher value within the lookback If price forms a lower low while fisher forms a higher low, it can signal a bullish divergence. Conversely, if price forms a higher high while fisher forms a lower high, a bearish divergence might be indicated. g) Bar Coloring The script monitors the absolute change in Fisher values from one bar to the next (sometimes called fisherChange): fisherChange = abs(fisher - fisher ) If fisherChange exceeds a user-defined intensityThreshold, bars are recolored to highlight a surge of momentum. Aqua might indicate a strong bullish surge, while purple might indicate a strong bearish surge. This color-coding provides a quick visual cue for traders looking to spot large momentum swings without constantly monitoring indicator values. 8. Signal Generation and Filtering Buy and sell signals occur when the Fisher line crosses the signal line in regions defined as oversold or overbought. The optional minimum movement filter prevents triggering if Fisher and its signal line are too close, reducing the chance of small, inconsequential price fluctuations creating frequent signals. Divergences that appear in oversold or overbought regions can serve as additional evidence that momentum might soon shift. 9. Visualization on the Chart Uptrick: Fisher Eclipse plots two lines: the Fisher line in one color and the signal line in a contrasting shade. The chart displays horizontal dashed lines where the overbought and oversold levels lie. When the Fisher Transform experiences a sharp jump or drop above the intensity threshold, the corresponding price bars may change color, signaling that momentum has undergone a noticeable shift. If the indicator detects bullish or bearish divergence, dotted lines are drawn on the oscillator portion to connect the relevant points. 10. Market Adaptability Because of the different aggressiveness levels and the optional minimum movement filter, Uptrick: Fisher Eclipse can be tailored to multiple trading styles. For instance, a short-term scalper might select a smaller length and more aggressive thresholds, while a swing trader might choose a longer length for smoother readings, along with conservative thresholds to ensure fewer but potentially stronger signals. During strongly trending markets, users might rely more on divergences or large intensity changes, whereas in a range-bound market, oversold or overbought conditions may be more frequent. 11. Risk Management Considerations Indicators alone do not ensure favorable outcomes, and relying solely on any one signal can be risky. Using a stop-loss or other protections is often suggested, especially in fast-moving or unpredictable markets. Divergence can appear before a market reversal actually starts. Similarly, a Fisher Transform can remain in an overbought or oversold region for extended periods, especially if the trend is strong. Cautious interpretation and confirmation with additional methods or chart analysis can help refine entry and exit decisions. 12. Combining with Other Tools Traders can potentially strengthen signals from Uptrick: Fisher Eclipse by checking them against other methods. If a moving average cross or a price pattern aligns with a Fisher crossover, the combined evidence might provide more certainty. Volume analysis may confirm whether a shift in market direction has participation from a broad set of traders. Support and resistance zones could reinforce overbought or oversold signals, particularly if price reaches a historical boundary at the same time the oscillator indicates a possible reversal. 13. Parameter Customization and Examples Some short-term traders run a 15-minute chart, with a shorter length setting, aggressively tight oversold and overbought thresholds, and a smaller divergence lookback. This approach produces more frequent signals, which may appeal to those who enjoy fast-paced trading. More conservative traders might apply the indicator to a daily chart, using a larger length, moderate threshold levels, and a bigger divergence lookback to focus on broader market swings. Results can differ, so it may be helpful to conduct thorough historical testing to see which combination of parameters aligns best with specific goals. 14. Realistic Expectations While the Fisher Transform can reveal potential turning points, no mathematical tool can predict future price behavior with full certainty. Markets can behave erratically, and a period of strong trending may see the oscillator pinned in an extreme zone without a significant reversal. Divergence signals sometimes appear well before an actual trend change occurs. Recognizing these limitations helps traders manage risk and avoids overreliance on any one aspect of the script’s output. 15. Theoretical Background The Fisher Transform uses a logarithmic formula to map a normalized input, typically ranging between -1 and +1, into a scale that can fluctuate around values like -3 to +3. Because the transformation exaggerates higher and lower readings, it becomes easier to spot when the market might have stretched too far, too fast. Uptrick: Fisher Eclipse builds on that foundation by adding a series of practical tools that help confirm or refine those signals. 16. Originality and Uniqueness Uptrick: Fisher Eclipse is not simply a duplicate of the basic Fisher Transform. It enhances the original design in several ways, including built-in divergence detection, bar-color triggers for momentum surges, thresholds for overbought and oversold levels, and customizable signal aggressiveness. By unifying these concepts, the script seeks to reduce noise and highlight meaningful shifts in market direction. It also places greater emphasis on helping traders adapt the indicator to their specific style—whether that involves frequent intraday signals or fewer, more robust alerts over longer timeframes. 17. Summary Uptrick: Fisher Eclipse is an expanded take on the original Fisher Transform oscillator, including divergence detection, bar coloring based on momentum strength, and flexible signal thresholds. By adjusting parameters like length, aggressiveness, and intensity thresholds, traders can configure the script for day-trading, swing trading, or position trading. The indicator endeavors to highlight where price might be shifting direction, but it should still be combined with robust risk management and other analytical methods. Doing so can lead to a more comprehensive view of market conditions. 18. Disclaimer No indicator or script can guarantee profitable outcomes in trading. Past performance does not necessarily suggest future results. Uptrick: Fisher Eclipse is provided for educational and informational purposes. Users should apply their own judgment and may want to confirm signals with other tools and methods. Deciding to open or close a position remains a personal choice based on each individual’s circumstances and risk tolerance.
Индикатор Pine Script®
от Uptrick
JJ Highlight Time Ranges with First 5 Minutes and LabelsTo effectively use this Pine Script as a day trader , here’s how the various elements can help you manage trades, track time sessions, and monitor price movements: Key Components for a Day Trader: 1. First 5-Minute Highlight: - Purpose: Day traders often rely on the first 5 minutes of the trading session to gauge market sentiment, watch for opening price gaps, or plan entries. This script draws a horizontal line at the high or low of the first 5 minutes, which can act as a key level for the rest of the day. - How to Use: If the price breaks above or below the first 5-minute line, it can signal momentum. You might enter a long position if the price breaks above the first 5-minute high or a short if it breaks below the first 5-minute low. 2. Session Time Highlights: - Morning Session (9:15–10:30 AM): The market often shows its strongest price action during the first hour of trading. This session is highlighted in yellow. You can use this highlight to focus on the most volatile period, as this is when large institutional moves tend to occur. - Afternoon Session (12:30–2:55 PM): The blue highlight helps you track the mid-afternoon session, where liquidity may decrease, and price action can sometimes be choppier. Day traders should be more cautious during this period. - How to Use: By highlighting these key times, you can: - Focus on key breakouts during the morning session. - Be more conservative in your trades during the afternoon, as market volatility may drop. 3. Dynamic Labels: - Top/Bottom Positioning: The script places labels dynamically based on the selected position (Top or Bottom). This allows you to quickly glance at the session's start and identify where you are in terms of time. - How to Use: Use these labels to remind yourself when major time segments (morning or afternoon) begin. You can adjust your trading strategy depending on the session, e.g., being more aggressive in the morning and more cautious in the afternoon. Trading Strategy Suggestions: 1. Momentum Trades: - After the first 5 minutes, use the high/low of that period to set up breakout trades. - Long Entry: If the price breaks the high of the first 5 minutes (especially if there's a strong trend). - Short Entry: If the price breaks the low of the first 5 minutes, signaling a potential downtrend. 2. Session-Based Strategy: - Morning Session (9:15–10:30 AM): - Look for strong breakout patterns such as support/resistance levels, moving average crossovers, or candlestick patterns (like engulfing candles or pin bars). - This is a high liquidity period, making it ideal for executing quick trades. - Afternoon Session (12:30–2:55 PM): - The market tends to consolidate or show less volatility. Scalping and mean-reversion strategies work better here. - Avoid chasing big moves unless you see a clear breakout in either direction. 3. Support and Resistance: - The first 5-minute high/low often acts as a key support or resistance level for the rest of the day. If the price holds above or below this level, it’s an indication of trend continuation. 4. Breakout Confirmation: - Look for breakouts from the highlighted session time ranges (e.g., 9:15 AM–10:30 AM or 12:30 PM–2:55 PM). - If a breakout happens during a key time window, combine that with other technical indicators like volume spikes , RSI , or MACD for confirmation. --- Example Day Trader Usage: 1. First 5 Minutes Strategy: After the market opens at 9:15 AM, watch the price action for the first 5 minutes. The high and low of these 5 minutes are critical levels. If the price breaks above the high of the first 5 minutes, it might indicate a strong bullish trend for the day. Conversely, breaking below the low may suggest bearish movement. 2. Morning Session: After the first 5 minutes, focus on the **9:15 AM–10:30 AM** window. During this time, look for breakout setups at key support/resistance levels, especially when paired with high volume or momentum indicators. This is when many institutions make large trades, so price action tends to be more volatile and predictable. 3. Afternoon Session: From 12:30 PM–2:55 PM, the market might experience lower volatility, making it ideal for scalping or range-bound strategies. You could look for reversals or fading strategies if the market becomes too quiet. Conclusion: As a day trader, you can use this script to: - Track and react to key price levels during the first 5 minutes. - Focus on high volatility in the morning session (9:15–10:30 AM) and **be cautious** during the afternoon. - Use session-based timing to adjust your strategies based on the time of day.
Индикатор Pine Script®
от JoanJagan
2
Previous Week High & Low with middle lineDescription: The Previous Week High & Low Indicator is a powerful tool designed to provide traders with key reference levels from the previous trading week. It dynamically calculates and plots the previous week's high, low, and midpoint levels directly on your chart, helping you identify critical support and resistance zones. Features: 1. **Previous Week High and Low Lines**: - The indicator displays the high and low prices of the previous trading week, allowing you to analyze price action relative to these levels. - These lines are plotted as step lines, visible only during the active trading days (Monday to Friday), ensuring clean and uncluttered charts. 2. Midpoint Line: - The midpoint between the previous week's high and low is calculated and displayed as a reference level. - This white line can act as a psychological pivot point for market participants. 3. Customizable Display: - You can toggle the visibility of the high and low lines using input options, tailoring the indicator to your preferences. 4. Precision and Aesthetics: - The lines are plotted with precision and styled for clarity, using subtle transparency for an unobtrusive yet informative appearance. Use Case: - This indicator is ideal for traders who rely on historical price levels for planning entries, exits, or stop-loss placements. - It works seamlessly with any timeframe and asset, making it versatile for various trading strategies. How It Works: - The indicator fetches the previous week's high and low prices using the weekly timeframe and "lookahead" mode to ensure these levels remain static after the week's close. - The lines are plotted only on weekdays (Monday to Friday) to exclude weekend data, ensuring accuracy for markets that operate 24/5. This tool simplifies your chart analysis and empowers you to make informed trading decisions based on historical price dynamics.
Индикатор Pine Script®
от mandragolaminum
Asia Sessions AutoPlotting**Asia Sessions AutoPlotting** This script is designed to automatically detect and plot the Asia session high and low levels directly on your chart, providing key session data for trading analysis. It is highly customizable, making it an essential tool for traders who rely on session data for decision-making. ### Key Features: - **Asia Session Detection**: Automatically identifies the Asia session based on user-defined time settings (default: 0000-0845 UTC). - **High/Low Line Plotting**: Displays high and low price levels for the session with customizable colors and line styles. - **Line Extensions**: Option to extend session high/low lines for future price action reference. - **Session Background Fill**: Adds an optional colored background to highlight the Asia session period. - **Day Labels**: Includes labels for the session high/low levels with the corresponding day of the week. - **Dynamic Session History**: Limits the display to a user-specified number of past sessions (default: 7) to keep the chart clean and focused. - **Customizable Colors**: Highlights Mondays with unique colors for easy identification, while other weekdays use a different scheme. ### Use Cases: - Identify key session levels for trading strategies. - Monitor Asia session dynamics and their impact on subsequent sessions. - Spot significant price reactions around session highs/lows. ### Inputs: - **Session Time**: Adjust the session time to match your preferred Asia trading hours. - **Toggle High/Low Lines**: Enable or disable the plotting of session highs and lows. - **Line Extensions**: Extend the session high/low lines into future bars for better visualization. - **Background Highlight**: Toggle a colored background for the Asia session. - **Maximum Sessions**: Define how many past sessions to display for clarity. This script is perfect for intraday traders, scalpers, and swing traders looking to gain insight into the Asia session and its influence on global markets. Fully adjustable and easy to use, it enhances your chart with critical information at a glance. Simply add it to your TradingView chart, configure your settings, and let it do the work for you!
Индикатор Pine Script®
от MCaesarAlgo
Fibonacci Extensions and Retracements for Selected TimeframesPurpose of the Script This script plots Fibonacci levels (retracements and extensions) based on the high and low points of the previous day, previous week, or previous month. It is a trading aid to help identify potential support and resistance zones. These zones are often used by traders to determine entry or exit points for trades. How It Works Select Timeframe The trader can choose whether to calculate Fibonacci levels based on the high and low points of the previous day, previous week, or previous month. This is selected using the timeframe_input input. Examples: "D" for the previous day "W" for the previous week "M" for the previous month Calculate Price Range The script calculates the price range using the high and low of the selected timeframe: Formula: price_range = High - Low Draw Fibonacci Levels Retracements: Within the price range, Fibonacci levels such as 12%, 23%, 38%, 50%, 61%, 78%, and 88% are calculated. These help identify potential support or resistance zones. Extensions: Beyond the price range, Fibonacci extensions such as 127%, 161%, 200%, 224%, and 241% are plotted to indicate potential breakout targets. Visualization The script plots lines and labels for each level. These lines extend to the right, providing real-time guidance during trading. Colors and line styles can be customized to match personal preferences. How to Use as a Trading Aid Use Fibonacci Retracements: Use retracements (e.g., 38%, 50%, 61%) to identify potential support or resistance zones. Example: If the price dropped sharply the previous day, the retracement levels could act as support during a rebound. Use Fibonacci Extensions: Extensions help identify price targets when the price breaks above or below the high or low of the previous day, week, or month. Example: After a breakout above the previous week’s high, the 127% or 161% level could serve as a target. Adjust Timeframe: Choose the timeframe that suits your strategy: Intraday traders can use the previous day’s high and low. Swing traders might prefer the previous week. Long-term traders could work with the previous month. Example A trader selects the weekly timeframe (W) to analyze the high and low of the previous week: The script calculates the price range based on the high and low of the previous week. Fibonacci retracements (e.g., 50% and 61%) are drawn to identify potential support zones. Fibonacci extensions (e.g., 127% and 161%) help define price targets for a potential breakout above or below the range.
Индикатор Pine Script®
от morris220768
1
Pivot Highs/Lows with Bar CountsWhat does the indicator do? This indicator adds labels to a chart at swing (a.k.a., "pivot") highs and lows. Each label may contain a date, the closing price at the swing, the number of bars since the last swing in the same direction, and the number of bars from the last swing in the opposite direction. A table is also added to the chart that shows the average, min, and max number of bars between swings. OK, but how do I use it? Many markets -- especially sideways-moving ones -- commonly cycle between swing highs and lows at regular time intervals. By measuring the number of bars between highs and lows -- both same-sided swings (i.e., H-H and L-L) and opposite-sided swings (i.e., H-L and L-H) -- you can then project the averages of those bar counts from the last high or low swing to make predictions about where the next swing high or low should occur. Note that this indicator does not make the projection for you. You have to determine which swing you want to project from and then use the bar counts from the indicator to draw a line, place a label, etc. Example: Chart of BTC/USD The indicator shows pivot highs and lows with bar counts, and it displays a table of stats on those pivots. If you focus on the center section of the chart, you can see that prices were moving in a sideways channel with very regular highs and lows. This indicator counts the bars between these pivots, and you could have used those counts to predict when the next high or low may have occurred. The bar counts do not work as well on the more recent section of the chart because there are no regularly time swings.
Индикатор Pine Script®
от swehba
1
AiTrend Pattern Matrix for kNN Forecasting (AiBitcoinTrend)The AiTrend Pattern Matrix for kNN Forecasting (AiBitcoinTrend) is a cutting-edge indicator that combines advanced mathematical modeling, AI-driven analytics, and segment-based pattern recognition to forecast price movements with precision. This tool is designed to provide traders with deep insights into market dynamics by leveraging multivariate pattern detection and sophisticated predictive algorithms. 👽 Core Features Segment-Based Pattern Recognition At its heart, the indicator divides price data into discrete segments, capturing key elements like candle bodies, high-low ranges, and wicks. These segments are normalized using ATR-based volatility adjustments to ensure robustness across varying market conditions. AI-Powered k-Nearest Neighbors (kNN) Prediction The predictive engine uses the kNN algorithm to identify the closest historical patterns in a multivariate dictionary. By calculating the distance between current and historical segments, the algorithm determines the most likely outcomes, weighting predictions based on either proximity (distance) or averages. Dynamic Dictionary of Historical Patterns The indicator maintains a rolling dictionary of historical patterns, storing multivariate data for: Candle body ranges, High-low ranges, Wick highs and lows. This dynamic approach ensures the model adapts continuously to evolving market conditions. Volatility-Normalized Forecasting Using ATR bands, the indicator normalizes patterns, reducing noise and enhancing the reliability of predictions in high-volatility environments. AI-Driven Trend Detection The indicator not only predicts price levels but also identifies market regimes by comparing current conditions to historically significant highs, lows, and midpoints. This allows for clear visualizations of trend shifts and momentum changes. 👽 Deep Dive into the Core Mathematics 👾 Segment-Based Multivariate Pattern Analysis The indicator analyzes price data by dividing each bar into distinct segments, isolating key components such as: Body Ranges: Differences between the open and close prices. High-Low Ranges: Capturing the full volatility of a bar. Wick Extremes: Quantifying deviations beyond the body, both above and below. Each segment contributes uniquely to the predictive model, ensuring a rich, multidimensional understanding of price action. These segments are stored in a rolling dictionary of patterns, enabling the indicator to reference historical behavior dynamically. 👾 Volatility Normalization Using ATR To ensure robustness across varying market conditions, the indicator normalizes patterns using Average True Range (ATR). This process scales each component to account for the prevailing market volatility, allowing the algorithm to compare patterns on a level playing field regardless of differing price scales or fluctuations. 👾 k-Nearest Neighbors (kNN) Algorithm The AI core employs the kNN algorithm, a machine-learning technique that evaluates the similarity between the current pattern and a library of historical patterns. Euclidean Distance Calculation: The indicator computes the multivariate distance across four distinct dimensions: body range, high-low range, wick low, and wick high. This ensures a comprehensive and precise comparison between patterns. Weighting Schemes: The contribution of each pattern to the forecast is either weighted by its proximity (distance) or averaged, based on user settings. 👾 Prediction Horizon and Refinement The indicator forecasts future price movements (Y_hat) by predicting logarithmic changes in the price and projecting them forward using exponential scaling. This forecast is smoothed using a user-defined EMA filter to reduce noise and enhance actionable clarity. 👽 AI-Driven Pattern Recognition Dynamic Dictionary of Patterns: The indicator maintains a rolling dictionary of N multivariate patterns, continuously updated to reflect the latest market data. This ensures it adapts seamlessly to changing market conditions. Nearest Neighbor Matching: At each bar, the algorithm identifies the most similar historical pattern. The prediction is based on the aggregated outcomes of the closest neighbors, providing confidence levels and directional bias. Multivariate Synthesis: By combining multiple dimensions of price action into a unified prediction, the indicator achieves a level of depth and accuracy unattainable by single-variable models. Visual Outputs Forecast Line (Y_hat_line): A smoothed projection of the expected price trend, based on the weighted contribution of similar historical patterns. Trend Regime Bands: Dynamic high, low, and midlines highlight the current market regime, providing actionable insights into momentum and range. Historical Pattern Matching: The nearest historical pattern is displayed, allowing traders to visualize similarities 👽 Applications Trend Identification: Detect and follow emerging trends early using dynamic trend regime analysis. Reversal Signals: Anticipate market reversals with high-confidence predictions based on historically similar scenarios. Range and Momentum Trading: Leverage multivariate analysis to understand price ranges and momentum, making it suitable for both breakout and mean-reversion strategies. Disclaimer: This information is for entertainment purposes only and does not constitute financial advice. Please consult with a qualified financial advisor before making any investment decisions.
Индикатор Pine Script®
от aibitcointrend
7
Fibonacci Moving Average PlusFibonacci Moving Average Plus is a sophisticated technical indicator that employs the first 15 numbers of the Fibonacci sequence to create dynamic moving average channels. This indicator aims to capture both immediate and long-term price movements by calculating Exponential Moving Averages (EMAs) based on these Fibonacci values. By using Fibonacci-based moving averages for both high and low price points, the indicator generates a visual channel that reflects the ebb and flow of market trends, acting as potential zones of support and resistance. Additionally, the indicator provides midline, retracement, and extension levels rooted in Fibonacci ratios, which are frequently observed as key levels for reversals or trend continuation. Ideology Behind Using Fibonacci Sequence-Based Moving Averages The Fibonacci sequence, known for its mathematical harmony and prevalence in natural patterns, is widely utilized in technical analysis to identify potential turning points in markets. In this indicator, the first 15 Fibonacci numbers (5, 8, 13, 21, etc.) are used as the lookback periods for EMAs to capture different layers of market sentiment. These moving averages represent timeframes that are theoretically in alignment with the natural rhythms of market cycles, where key levels—often coinciding with Fibonacci numbers—can act as magnetic points for price. The Fibonacci high and low channels aim to encapsulate price action, giving traders a sense of whether the market is trending, consolidating, or experiencing reversal pressure. These levels, grounded in both mathematics and market psychology, help traders spot areas where price might face resistance or find support. Key Features Fibonacci Moving Average High and Low: This indicator calculates the high and low EMAs based on Fibonacci sequence numbers (e.g., 5, 8, 13, etc.) for enhanced trend analysis. Golden Pocket Retracement (GPR) and Extension (GPE) Bands: Displays common Fibonacci retracement and extension levels (0.618, 0.65 for retracement, and 1.618, 1.65 for extension). Midline: Plots the average of the Fibonacci high and low to act as an additional reference level. Stop-Loss Levels: Provides suggested stop-loss levels based on Fibonacci levels for both long and short positions. Basic User Guide Adjust Input Settings: Input Timeframe: Set a specific timeframe for the Fibonacci moving average calculation, separate from the chart's primary timeframe. Show Fibonacci MA High/Low: Toggle the visibility of the high and low Fibonacci moving averages. Show Mid Line: Display a midline for added trend reference. Show Golden Pocket Bands: Choose to display retracement or extension bands for potential support or resistance zones. Show Stop-Loss Levels: Enable to visualize potential stop-loss levels for both long and short trades. Interpretation: Fibonacci MA High and Low: Use these lines to gauge the general trend. When the price is above both, it may indicate an uptrend; below both, a downtrend. Golden Pocket Retracement: This zone (between 0.618 and 0.65) is often a key level for potential reversals or support/resistance. Golden Pocket Extension: The 1.618 and 1.65 levels can indicate potential profit-taking or trend exhaustion points. Stop-Loss Levels: The calculated stop-loss levels (long SL below and short SL above) can aid in risk management. Customization: You can customize the appearance and visibility of each component through the input settings to fit your specific strategy and visual preferences. This indicator should be used alongside other technical analysis tools to provide a more comprehensive trading approach. This Indicator would not exist without the original contributions and blessing from Sofien Kaabar
Индикатор Pine Script®
от SwizzleShizzle
2
CandlestickPatternsLibrary "CandlestickPatterns" zigzag(_low, _high, depth, deviation, backstep)   Parameters:      _low (float)      _high (float)      depth (int)      deviation (int)      backstep (int) getTrend(trendType, currentClose, zz_downtrend, zz_uptrend, ema14, ema28)   Parameters:      trendType (string)      currentClose (float)      zz_downtrend (bool)      zz_uptrend (bool)      ema14 (float)      ema28 (float) isInside(currentHigh, currentLow, currentClose, currentOpen, prevHigh, prevLow)   Parameters:      currentHigh (float)      currentLow (float)      currentClose (float)      currentOpen (float)      prevHigh (float)      prevLow (float) checkMorningStar(open0, high0, low0, close0, open1, high1, low1, close1, open2, high2, low2, close2, innerCandleThreshold, closingMinThreshold, closingMaxThreshold, useDojiFilter, dojiSize, downTrend)   Parameters:      open0 (float)      high0 (float)      low0 (float)      close0 (float)      open1 (float)      high1 (float)      low1 (float)      close1 (float)      open2 (float)      high2 (float)      low2 (float)      close2 (float)      innerCandleThreshold (float)      closingMinThreshold (float)      closingMaxThreshold (float)      useDojiFilter (bool)      dojiSize (float)      downTrend (bool) checkEveningStar(open0, high0, low0, close0, open1, high1, low1, close1, open2, high2, low2, close2, innerCandleThreshold, closingMinThreshold, closingMaxThreshold, useDojiFilter, dojiSize, upTrend)   Parameters:      open0 (float)      high0 (float)      low0 (float)      close0 (float)      open1 (float)      high1 (float)      low1 (float)      close1 (float)      open2 (float)      high2 (float)      low2 (float)      close2 (float)      innerCandleThreshold (float)      closingMinThreshold (float)      closingMaxThreshold (float)      useDojiFilter (bool)      dojiSize (float)      upTrend (bool) checkHammerPattern(open, high, low, close, bodyAvg, shadowFactor, downTrend)   Parameters:      open (float)      high (float)      low (float)      close (float)      bodyAvg (float)      shadowFactor (float)      downTrend (bool) checkInvertedHammerPattern(open, high, low, close, bodyAvg, shadowFactor, downTrend)   Parameters:      open (float)      high (float)      low (float)      close (float)      bodyAvg (float)      shadowFactor (float)      downTrend (bool) checkHangingManPattern(open, high, low, close, bodyAvg, shadowFactor, upTrend)   Parameters:      open (float)      high (float)      low (float)      close (float)      bodyAvg (float)      shadowFactor (float)      upTrend (bool) checkShootingStarPattern(open, high, low, close, bodyAvg, shadowFactor, upTrend)   Parameters:      open (float)      high (float)      low (float)      close (float)      bodyAvg (float)      shadowFactor (float)      upTrend (bool) checkLevels(high0, high1, high2, low0, low1, low2, lookbackPeriod)   Parameters:      high0 (float)      high1 (float)      high2 (float)      low0 (float)      low1 (float)      low2 (float)      lookbackPeriod (int)
Библиотека Pine Script®
от s_d_t
MSTR-BTC PremiumThis custom indicator, “MSTR-BTC Premium with High, Average, and Low Levels,” helps you analyze the premium of MicroStrategy Incorporated’s (MSTR) stock price in relation to its Bitcoin holdings. By comparing the market capitalization of MSTR to the value of its Bitcoin holdings (using BTCUSD from Coinbase), this indicator calculates a premium that reflects how much the stock price deviates from its Bitcoin-related value. Key Features: • Premium Line: The primary feature is the “Premium,” which shows the ratio of MSTR’s market cap relative to its Bitcoin holdings and the BTCUSD price. • High, Average, and Low Levels: The indicator calculates the highest, lowest, and average premium values over a user-defined period (default is 14 bars). These levels help identify overbought and oversold conditions relative to the stock’s Bitcoin valuation. • Visual Shading: The area between the premium line and the average is shaded, making it easier to see when the premium is above or below its typical level. Optional shading is also available between the high and low levels to visualize the price range. How to Use: • Overbought/Undervalued Conditions: When the premium line rises significantly above the average, it may indicate that MSTR stock is overbought compared to its Bitcoin holdings. Conversely, when the premium falls below the average or approaches the low line, it might signal an undervalued opportunity. • Trend and Mean Reversion: The high and low lines provide insight into extreme levels. Monitoring these alongside the average can assist in identifying potential mean reversion trades. Customization: • Calculation Period: The period for calculating the high, low, and average values can be adjusted to suit your trading strategy (default is 14). • Shading Options: By default, the area between the premium and its average is shaded. You can enable or disable the shading between the high and low as needed. This indicator is particularly useful for traders and investors following MicroStrategy (MSTR) and its Bitcoin strategy, providing a deeper understanding of the stock’s relationship to its underlying Bitcoin assets. It can assist in identifying key levels for decision-making based on deviations from historical norms. How to Add the Indicator: 1. Adjust the calculation period (default is 14) to customize the analysis according to your preferred timeframe. 2. Watch for significant deviations of the premium line from its average to identify potential overbought/oversold conditions. 3. Use the high and low levels to help gauge extreme premium values and possible mean reversion opportunities. Enjoy the analysis and make more informed decisions with the MSTR-BTC Premium Indicator! This description should be clear and informative for anyone considering using your indicator. It highlights the functionality, purpose, and customization options in a straightforward way. Let me know if you’d like to tweak or adjust any part of it!
Индикатор Pine Script®
от Tin2100
12
Amplitude [Anan]The Amplitude indicator calculates and visualizes both the amplitude and cumulative amplitude of price movements, providing traders with insights into price volatility and trend strength. By distinguishing between positive and negative amplitude movements, this indicator aids in identifying bullish and bearish sentiments, potential reversal points, and confirming trend directions. █ Main Formulas ‣ Amplitude = High - Low ‣ Cumulative Amplitude = sum of Amplitude over the specified lookback period ‣ Percentage Amplitude = (Amplitude / Open) × 100% High: Candle high (or highest high when lookback > 1) Low: Candle low (or lowest low when lookback > 1) Open: Open price of the first candle in the lookback period █ Key Features ✦Dual Amplitude Calculations: Amplitude: Reflects price range and direction over a short-term period. Cumulative Amplitude: Aggregates amplitude over a longer period for broader trend analysis. ✦Customizable Parameters: Adjust lookback periods, smoothing options, moving averages and Alerts. ✦Direction Separation: Distinguish between positive and negative amplitude movements to identify market sentiment. ✦Flexible Visualization: Customizable colors and plot styles for enhanced chart readability. ✦Alert System: Generate signals based on amplitude direction and moving average crossovers █ How to Use and Interpret ✦Understanding Amplitude and Cumulative Amplitude: ‣Amplitude: Measures the price range (high - low) over a specified short-term period. ‣Cumulative Amplitude: Aggregates amplitude over a defined longer-term period. ‣Percentage Representation: shows amplitude relative to the open price from `amp_length` bars ago, providing a normalized view. ‣Interpretation: Large Amplitude Values: Indicate high volatility. Small Amplitude Values: Indicate low volatility. ✦Trend Identification: ‣Uptrend: Consistently positive amplitudes and upward-moving averages. ‣Downtrend: Consistently negative amplitudes and downward-moving averages. ✦Overbought/Oversold Conditions: ‣High Positive Amplitude: May indicate overbought conditions and potential reversals. ‣High Negative Amplitude: May indicate oversold conditions and potential reversals. ✦Volatility Analysis: ‣High Amplitude Values: Suggest increased market volatility. ‣Low Amplitude Values: Suggest reduced market volatility. ✦Signal Confirmation: ‣Moving Average Crossovers: Confirm the strength and direction of trends, aiding in informed trading decisions. ✦Trading Strategies: ‣ Breakout Trading: Large increases in amplitude can signal potential breakouts. ‣ Mean Reversion: Extreme amplitude values may indicate upcoming price corrections. ‣ Volatility-Based Strategies: Adjust position sizes or trading frequency based on amplitude magnitudes. ‣ Multi-Timeframe Analysis: Compare amplitudes across different timeframes for a comprehensive market view. █ Customization Tips ‣ Lookback Periods: Experiment with different periods to suit your trading style and asset characteristics. ‣ Smoothing Settings: Adjust to balance responsiveness and noise reduction. ‣ Percentage Amplitude: Use for normalized comparisons across different price levels.
Индикатор Pine Script®
от Mohamed3nan
DTB Dynamic Trendline Bands with Buy/Sell Pressure Detection This indicator provides a comprehensive analysis of price movements by incorporating smoothed high and low bands, a midline, and the detection of buying and selling pressure. It is designed to help traders identify key support and resistance levels as well as potential buy and sell signals. **Features:** - **Smooth High and Low Bands:** Based on the highest high and lowest low over a specified period, smoothed using a simple moving average (SMA) to reduce noise and enhance clarity. - **Midline:** The average of the smoothed high and low bands, providing a central reference point for price movements. - **Buying and Selling Pressure Detection:** Highlights candles with significant buying or selling pressure, indicated by light green for buying pressure and light red for selling pressure. This is determined based on volume thresholds and price movement. - **Trendlines:** Dynamic trendlines are drawn based on recent highs and lows, helping to visualize the current trend direction. **How to Use:** 1. **High-Low Bands:** Use these bands to identify key support and resistance levels. 2. **Midline:** Monitor the midline for potential mean reversion trades. 3. **Buying/Selling Pressure Candles:** Look for candles highlighted in light green or red to identify potential buy or sell signals. 4. **Trendlines:** Follow the dynamic trendlines to understand the direction of the current trend. **Inputs:** - **Length:** Number of bars to consider for calculating the highest high and lowest low (default: 200). - **Smooth Length:** Period for the simple moving average to smooth the high and low bands (default: 10). - **Volume Threshold Multiplier:** Multiplier for the average volume to detect significant buying or selling pressure (default: 1.5). This indicator is suitable for all timeframes and can be used in conjunction with other technical analysis tools to enhance your trading strategy.
Индикатор Pine Script®
от bidarmaj
2
Stop Hunts [MK]Liquidity rests above/below previous highs and lows because these are the areas where traders are most likely to leave their orders/stop losses. The market can tap into this liquidity source by going beyond the previous highs and lows, this liquidity can then be used to reverse the market in the opposite direction. As traders we may want to know if price will continue beyond previous highs and lows, or reverse the market. If price looks to be reversing after tapping into liquidity, this can be a good area to enter a trade. The same area can be used as a take profit level also. The indicator identifies previous high/lows in two ways: 1. previous high/lows using 'PIVOT POINTS'. Pivots are easy to spot and are obvious within a price trend. Also called 'higher highs", "lower lows" etc. The number of candles required to form the pivot point can be adjusted in the script settings. see below example of pivot point and stop hunt: www.tradingview.com see how price reversed upwards after stop hunt on pivot point above. 2. previous candle high/lows. A previous candles high and low are also good areas of liquidity. see below example of previous candle stop hunt: see how price reversed upwards after stop hunt on previous candle low above. Personally, I use the pivot point stop hunts on lower timeframes and previous candle stop hunts on higher timeframes. However users can adjust on which timeframes to show the indicator depending on their own trading style. As ever all items within 'settings' are customizable. The indicator is by no means a 'trading strategy' and users should be fully aware of the stop hunt concept and have conducted extensive back-testing before using with 'live' accounts. The indicator may also serve as a 'teaching aid' to new students and as a reminder to more experienced traders.
Индикатор Pine Script®
от malk1903
4
MarketRangerThis indicator puts a selection of elements together providing traders with insights into price dynamics, trend changes, and potential trading opportunities within the specified timeframe. Trading Range Defined by Support and Resistance : Support and resistance levels are calculated using the lowest low and highest high over specified periods. These levels define the boundaries of the trading range within which the price moves. WMA Color Changing based on Slope : The script uses three Weighted Moving Averages (WMAs) with different lengths. The color of the main WMA changes based on its slope. When the slope of the WMA is positive (indicating an uptrend), it's displayed in blue. When it's negative (indicating a downtrend), it's displayed in pink. New High/Low Detection : The script detects new highs and lows in the price action. A new high is detected when the current high crosses under the previous resistance level, and a new low is detected when the current low crosses over the previous support level. These detections are marked by triangle shapes above or below the bars. WMA Crosses : The script calculates the difference between the two WMAs. When the faster WMA crosses above the slower WMA, indicating a potential bullish signal, a blue cross shape is plotted below the bar. When the faster WMA crosses below the slower WMA, indicating a potential bearish signal, a pink cross shape is plotted above the bar. Slope Changes : The script calculates the slope of the main WMA and tracks changes in slope. A positive slope indicates an upward trend, while a negative slope indicates a downward trend. Slope changes from negative to positive indicate potential bullish momentum, and from positive to negative indicate potential bearish momentum. Customizable Pivot Levels : Pivot levels are calculated based on user-defined percentages of the range between support and resistance. Pivot Level 1 and Pivot Level 2 provide additional reference points for potential reversals or trend continuation. Usage : The indicator provides support and resistance levels, new high/low alerts, and WMA crosses. The midpoint and customizable pivot levels offer potential trading zones. Slope change points indicate potential shifts in market sentiment. Customize the pivot levels according to your trading strategy. Parameters : Adjust the WMA lengths and support/resistance lengths to suit your trading style. Modify the visibility settings to control how many periods of support and resistance are displayed. Customize the pivot levels to fit your preferred trading strategy. Alerts : Alerts are triggered for new high/low points and WMA crosses. Use alerts to stay informed about potential trading opportunities. Interpretation : Watch for new high/low points for potential trend reversals or continuations. Monitor WMA crosses and slope changes for signals of market direction. Consider trading near support/resistance levels and pivot points. Additional Notes : Experiment with different settings to find the configuration that best suits your trading preferences. Backtest the indicator on historical data to validate its effectiveness before using it in live trading.
Индикатор Pine Script®
от Dantawe
Advanced MACD [CryptoSea]Advanced MACD (AMACD) enhances the traditional MACD indicator, integrating innovative features for traders aiming for deeper insights into market momentum and sentiment. It's crafted for those seeking to explore nuanced behaviors of the MACD histogram, thus offering a refined perspective on market dynamics. Divergence moves can offer insight into continuation or potential reversals in structure, the example below is a clear continuation signal. Key Features Enhanced Histogram Analysis: Precisely tracks movements of the MACD histogram, identifying growth or decline periods, essential for understanding market momentum. High/Low Markers: Marks the highest and lowest points of the histogram within a user-defined period, signaling potential shifts in the market. Dynamic Averages Calculation: Computes average durations of histogram phases, providing a benchmark against historical performance. Color-Coded Histogram: Dynamically adjusts the histogram's color intensity based on the current streak's duration relative to its average, offering a visual cue of momentum strength. Customisable MACD Settings: Enables adjustments to MACD parameters, aligning with individual trading strategies. Interactive Dashboard: Showcases an on-chart table with average durations for each phase, aiding swift decision-making. Settings & Customisation MACD Settings: Customise fast length, slow length, and signal smoothing to tailor the MACD calculations to your trading needs. Reset Period: Determine the number of bars to identify the histogram's significant high and low points. Histogram High/Lows: Option to display critical high and low levels of the histogram for easy referencing. Candle Colours: Select between neutral or traditional candle colors to match your analytical preferences. When in strong trends, you can use the average table to determine when to look to get into a position. This example we are in a strong downtrend, we then see the histogram growing above the average in these conditions which is where we should look to get into a shorting position. Strategic Applications The AMACD serves not just as an indicator but as a comprehensive analytical tool for spotting market trends, momentum shifts, and potential reversal points. It's particularly useful for traders to: Spot Momentum Changes Utilise dynamic coloring and streak tracking to alert shifts in momentum, helping anticipate market movements. Identify Market Extremes Use high and low markers to spot potential market turning points, aiding in risk management and decision-making. Alert Conditions Above Average Movement Alerts: Triggered when the duration of the MACD histogram's growth or decline is unusually long, these alerts signal sustained momentum: Above Zero: Alerts for both growing and declining movements above zero, indicating either continued bullish trends or potential bearish reversals. Below Zero: Alerts for growth and decline below zero, pointing to potential bullish reversals or confirmed bearish trends. High/Low Break Alerts: Activated when the histogram reaches new highs or falls to new lows beyond the set thresholds, these alerts are crucial for identifying shifts in market dynamics: Break Above Last High: Indicates a potential upward trend as the histogram surpasses recent highs. Break Below Last Low: Warns of a possible downward trend as the histogram drops below recent lows. These alert conditions enable traders to automate part of their market monitoring or potential to automate the signals to take action elsewhere.
Индикатор Pine Script®
от CryptoSeaTV
1
Implied Orderblock Breaker (Zeiierman)█ Overview The Implied Order Block Breaker (Zeiierman) is a tool designed to identify enhanced order blocks with imbalances. These enhanced order blocks represent areas where there is a rapid price movement. Essentially, this indicator uses order blocks and suggests that a swift price movement away from these levels, breaking the current market structure, could indicate an area that the market has not correctly valued. This technique offers traders a unique method to identify potential market inefficiencies and imbalances, serving as a guide for potential price revisits. The indicator doesn't scan for imbalances in the traditional sense — where there's an absence of trades between two price levels — but instead, it identifies quick movements away from key levels that suggest where an imbalance might exist. Relying on crossovers and cross-unders in conjunction with pivot points and examining the high/low within the same period provides an innovative method for traders to spot these potentially undervalued or overvalued areas in the market. These inferred imbalances can be crucial for traders looking for price levels where the market might make significant moves. █ How It Works Bullish Crossover: The closing price of a bar crosses above a pivot high, which is an indication that buyers are in control and pushing the price upwards. New Low Within Period: There is a lower low within the same period as the pivot high. This suggests that after setting a high, the market pulled back to set a new low, potentially leaving a price gap on the way up as the price quickly recovers. Bearish Crossunder: The closing price of a bar crosses under a pivot low, indicating that sellers are taking control and driving the price down. New High Within Period: There is a higher high within the same period as the pivot low. This condition suggests that the market rallied to a new high before falling back below the pivot low, potentially leaving a gap on the way down. █ How to Use The enhanced order blocks are often revisited, and the price may aim to 'fill' the potential imbalance created by the rapid price movement, thereby presenting traders with potential entry or exit points. This approach aligns with the idea that imbalances are frequently revisited by the market, and when combined with the context of Order Blocks, it provides even more confluence. Example Here, if the price drops rapidly after setting a new high—crossing under the pivot low—it may skip over certain price levels, creating a 'gap' that signifies an area where the price might have been overvalued (imbalance), which the market may revisit for a potential price correction or revaluation. █ Settings Period: Determines the number of bars used for identifying pivot highs and lows. A higher value gives more significant but less frequent signals, while a lower value increases sensitivity but might give more false positives. Pivot Surrounding: Specifies the number of candles to analyze around a pivot point. Increasing this value broadens the analysis range, potentially capturing more setups but possibly including less significant ones. ----------------- Disclaimer The information contained in my Scripts/Indicators/Ideas/Algos/Systems does not constitute financial advice or a solicitation to buy or sell any securities of any type. I will not accept liability for any loss or damage, including without limitation any loss of profit, which may arise directly or indirectly from the use of or reliance on such information. All investments involve risk, and the past performance of a security, industry, sector, market, financial product, trading strategy, backtest, or individual's trading does not guarantee future results or returns. Investors are fully responsible for any investment decisions they make. Such decisions should be based solely on an evaluation of their financial circumstances, investment objectives, risk tolerance, and liquidity needs. My Scripts/Indicators/Ideas/Algos/Systems are only for educational purposes!
Индикатор Pine Script®
от Zeiierman
30
Donch +This is an indicator I made for trading Forex to help me see the bigger picture. It is meant for the 30min TF and it includes the following: - 20 Day High | Low - 5 Day High | Low - 4 Hour High | L - 4 Hour Bars - Daily Simple Moving Averages - Weekly Trend Line (connects last week's open to this week's open) - Daily Trend Line (connects yesterday's open to today's open) - Horizontal Lines at 0.25% increments (these can be useful for S/R... currency rarely moves more than 1% in a day). - A table with information about what markets are open and technicals on the pair I am looking at. - A slight white background fill to highlight the first hour of the US session. Knowing what session you are in is very important in day trading (in my opinion). This lets me go back and see how the US has been trading. To keep the chart from being "too busy" (it's plenty busy lol), I use a step line and focus on 30min closes. I reference the white lines above and below closes for 4hr highs/lows and don't bother with looking at the high/low of every 30 min bar. For the table, you will see bright green by the country for the first hour of trading in that session. It will turn to a regular green after the first hour. It will turn yellow the final hour of that session. It will turn red if that market is closed. You can select from the settings 'inputs' tab to enable/disable any parts of this you don't find useful, for the table you'd go over to the 'style' tab and unselect it there. For example, I don't use the labels regularly. If I were to get confused about what a moving average was or something, I'd enable the labels and clarify. Currency doesn't like to break out and likes to be stable. Keeping this in mind, you can see how the 20 day high / low and the 5 day high / low act as support and resistance (unless there is a news event to break out on. I have alerts for the following: - Price update every hour - Crossing a trend line - Crossing a moving average - Crossing a 0.25% increment - Making a new 4 hour, 5 day, or 20 day high/low To enable the alerts, you would click add alert, select the indicator, and click save. To work properly, you'd want to be on the 30min TF before doing this. You will get a lot of alerts (personally I like this because I like to see how currency moves throughout the day). You will get one notification per 30 minutes but not more than that for the particular alert.
Индикатор Pine Script®
от codysettle
2
Channels With Patterns [ChartPrime]The Channels With Patterns indicator is an attempt at minimizing the delay in forming a trend channel. This indicator uses a single pivot in conjunction with a smooth version of the price to estimate the direction of an emerging trend. Using ATR, this indicator estimates the volatility of the new trend by adjusting the channel size by a multiple of the current ATR. One of the biggest complains for any trend indicator is that it takes too long to create a channel or trend line. This indicator estimates the trend channel by checking if the price is moving in the correct direction and then it projects the channel from a single pivot. To allow for some margin of error, this script uses an offset to help center the channel. This offset is generated from the ATR at the time of formation. In conjunction with forming estimated trend channels, this indicator features select candle stick patterns. These candle stick patterns are filtered by location in the formed trend channel. If the price is within an extremity of the trend channel it will appear. Filtering classical vanilla candle stick patterns using this methodology can result in some interesting results and possible confluence points for traders. For example; a bearish hammer appearing when filtered in an upper zone might add an extra level of realtime unique confluence traders. Traders can use this script as a general trend line indicator that is a bit more forward looking than others, or it can be used it as its full blown trend channel estimator. Due to the fact that this is an estimate using the minimum possible information to make the channel, its accuracy will not always be perfect and can suffer compared to alternative methods. When configuring the indicator it is important to understand the role of each input. Here is a description of all of the settings provided: Presets (`preset`): This input allows users to quickly configure the indicator based on the market they are trading in. Selecting "Stocks," "Forex," or "Crypto" automatically adjusts various parameters to settings deemed optimal for these markets. The "User" option lets traders manually configure settings for a more personalized approach. Style (`style`): This setting determines how pivot points are calculated. "Wick" uses the high and low of candlesticks (including wicks), which can be more sensitive to market extremes. "Body" uses only the open and close prices (the body of the candlesticks), potentially offering a more stable pivot point calculation. Break Style (`break_style`): This option defines what price is used to determine if a channel has been broken. "Close" uses the closing price of a candlestick, while "High/Low" uses the highest and lowest prices. This affects how channel breaks are identified and can influence trading signals. Instant Mode (`instant`): When enabled, this feature allows the indicator to form channels more quickly by initiating them as soon as potential formations are detected. This can provide earlier signals but may increase the risk of false positives. ATR Length (`atr_length`): This input sets the period for the Average True Range (ATR), a common volatility indicator. A longer ATR period may smooth out the channel but could delay responsiveness to market changes. A shorter period might make the channel more responsive but potentially more erratic. Offset Center (`offset`): Adjusts the vertical positioning of the channel. This can help in aligning the channel more accurately with the price action, depending on market conditions and personal trading strategies. Size (`atr_multiplier`): Alters the channel's size relative to the ATR. A higher multiplier makes a wider channel, which might be useful in more volatile markets. A lower multiplier tightens the channel, which could be better for less volatile conditions. Padding % (`padding`): This setting adjusts the padding within the top and bottom quarters of the channel. It essentially fine-tunes the channel's sensitivity to price movements near its boundaries. Pivot Length (`pivot_length`): Determines the number of bars used to calculate pivot points. A longer length may provide more significant pivot points but can reduce the number of channels formed. Pivot Look Forward (`look_forward`): Sets the number of bars to look forward in the pivot calculation, affecting how quickly the channel adapts to new pivots. Average H/L Length (`avg_length`): Controls the smoothing of the high and low prices used in the channel calculation. A longer average length can lead to smoother, more gradual channel slopes. Enable Hammer (`enable_hammer`): When enabled, the indicator will highlight Hammer candlestick patterns, which are often considered bullish reversal indicators. Enable Inverted Hammer (`enable_ihammer`): This toggles the display of Inverted Hammer patterns, typically viewed as potential bullish reversal signals. Enable Bullish Engulfing (`enable_bullish_engulfing`): Enables the identification of Bullish Engulfing patterns, another type of bullish reversal indicator. Enable Bearish Engulfing (`enable_bearish_engulfing`): When activated, this highlights Bearish Engulfing patterns, which are often interpreted as bearish reversal signals. Extend Channel (`extend`): This option, when enabled, extends the drawn channels forward until they are either broken or a new channel is formed. Show Break Label (`show_break_label`): Toggles the display of labels indicating where the channel has been broken, providing visual cues for potential trade entries or exits. Channel History Length (`history_length`): Determines how many historical channels are displayed on the chart. This can be useful for analyzing past performance and patterns. Channel Colors (`top_color`, `bottom_color`, `center_color`): These settings allow customization of the channel's appearance by setting the colors of the top, bottom, and center lines. Line Transparency (`line_trans`): Adjusts the transparency of the channel lines, helping to balance visibility with chart readability. Center Line Transparency (`center_trans`): Specifically sets the transparency level of the center line of the channel. Channel Fill Transparency (`fill_trans`): Modifies the transparency of the filled areas between the channel lines, which can enhance chart clarity and focus on the price action. Break Colors (`break_up_color`, `break_down_color`): Sets the colors for labels that appear when the channel is broken, either upwards or downwards. Break Label Text Color (`text_color`): Determines the color of the text in the break labels, enhancing readability based on the chart's background and color scheme. Candle Pattern Colors (`h_color`, `ih_color`, `bullish_engulfing_color`, `bearish_engulfing_color`): These inputs allow for the customization of the colors used to highlight various candle patterns on the chart. Candle Pattern Text Color (`candle_text_color`): Sets the color of the text for labels associated with candle pattern indicators. Alerts (`new_channel_alert`, `break_alert`, `hammer_alert`, `ihammer_alert`, `bullish_engulfing_alert`, `bearish_engulfing_alert`): These toggles enable or disable alerts for different events, such as the formation of new channels, channel breaks, or the appearance of specific candle patterns. This feature is crucial for traders who rely on timely notifications for potential trading opportunities. We have provided a few presets to allow you to get a feeling for how the indicator works with different settings easily. Here is a description of the settings used in each preset: Stocks Preset: Style: "Wick" Break Style: False (High/Low) Instant Mode: True ATR Length: 10 Size (ATR Multiplier): 4 Pivot Length: 10 Pivot Look Forward: 15 Average H/L Length: 18 Forex Preset: Style: "Wick" Break Style: False (High/Low) Instant Mode: True ATR Length: 100 Size (ATR Multiplier): 5 Pivot Length: 10 Pivot Look Forward: 15 Average H/L Length: 18 Crypto Preset: Style: "Wick" Break Style: False (High/Low) Instant Mode: True ATR Length: 10 Size (ATR Multiplier): 4 Pivot Length: 10 Pivot Look Forward: 15 Average H/L Length: 18 This script first starts by defining and collecting the relevant data for the main body of the code with data(). This generates the pivot data, the levels, the ranges, the averages, the deltas, and finally the candle sticks. Once there is a higher low, or lower high detected via the pivots and the current price it triggers the formation of the new channel. It takes the delta between the last pivot and the current average price and projects the trend channel using this delta. If the price exceeds the extremities of the channel it will classify this as a break from the estimated structure and begin looking for a new channel. The idea is that when trending, the price will oscillate between extremities as defined by a range and direction. If the price is inside of one of these extremities the script will look for candle stick patterns. This is how the script operates. On a more technical level, this script is meant to showcase Pine Script's custom types and methods. We have made use of a properties pattern allows functions to use a minimal number of arguments. This allows you to add new inputs without modifying a string of functions. The use of methods and data structures allows the main body of the code to be easy to understand and for the script as a whole to be easily modified. We have made sure that the script is modular so that users can incorporate this into their own custom scripts. It should be easy to expand on this script as the main logic is fairly compact and open for easy modification. All features are packed into their own function for easy use elsewhere. This is particularly evident in the candle stick section. I have simplified the process of creating candle stick patterns by creating a type. All users have to do is make methods for this type. candle()=> polarity = open < close body_top = math.max(open, close) body_bottom = math.min(open, close) body_range = body_top - body_bottom top_wick = high - body_top bottom_wick = body_bottom - low average_body = ta.ema(body_range, 14) average_top_wick = ta.ema(top_wick, 14) average_bottom_wick = ta.ema(bottom_wick, 14) has_body = body_range != 0 has_top_wick = top_wick != 0 has_bottom_wick = bottom_wick != 0 above_average_body = body_range > average_body above_average_top_wick = top_wick > average_top_wick above_average_bottom_wick = bottom_wick > average_bottom_wick candle_data.new( polarity , body_top , body_bottom , body_range , top_wick , bottom_wick , average_body , average_top_wick , average_bottom_wick , has_body , has_top_wick , has_bottom_wick , above_average_body , above_average_top_wick , above_average_bottom_wick ) In conclusion, this script offers a blend of rapid trend channel formation and candlestick pattern recognition, making it a unique tool for traders looking for a more proactive approach to trend analysis.
Индикатор Pine Script®
от ChartPrime
18